{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--NAVIGATION-->\n",
    "< [简单的散点图](04.02-Simple-Scatter-Plots.ipynb) | [目录](Index.ipynb) | [密度和轮廓图](04.04-Density-and-Contour-Plots.ipynb) >\n",
    "\n",
    "<a href=\"https://colab.research.google.com/github/wangyingsm/Python-Data-Science-Handbook/blob/master/notebooks/04.03-Errorbars.ipynb\"><img align=\"left\" src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open in Colab\" title=\"Open and Execute in Google Colaboratory\"></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualizing Errors\n",
    "\n",
    "# 误差可视化"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> For any scientific measurement, accurate accounting for errors is nearly as important, if not more important, than accurate reporting of the number itself.\n",
    "For example, imagine that I am using some astrophysical observations to estimate the Hubble Constant, the local measurement of the expansion rate of the Universe.\n",
    "I know that the current literature suggests a value of around 71 (km/s)/Mpc, and I measure a value of 74 (km/s)/Mpc with my method. Are the values consistent? The only correct answer, given this information, is this: there is no way to know.\n",
    "\n",
    "对于任何的科学测量来说，精确计算误差与精确报告测量值基本上同等重要，如果不是更加重要的话。例如，设想我正在使用一些天文物理学观测值来估算哈勃常数，即本地观测的宇宙膨胀系数。我从一些文献中知道这个值大概是71 (km/s)/Mpc，而我测量得到的值是74 (km/s)/Mpc,。这两个值是否一致？在仅给定这些数据的情况下，这个问题的答案是，无法回答。\n",
    "\n",
    "译者注：Mpc（百万秒差距）参见[秒差距](https://zh.wikipedia.org/wiki/%E7%A7%92%E5%B7%AE%E8%B7%9D)\n",
    "\n",
    "> Suppose I augment this information with reported uncertainties: the current literature suggests a value of around 71 $\\pm$ 2.5 (km/s)/Mpc, and my method has measured a value of 74 $\\pm$ 5 (km/s)/Mpc. Now are the values consistent? That is a question that can be quantitatively answered.\n",
    "\n",
    "如果我们将信息增加一些，给出不确定性：最新的文献表示哈勃常数的值大约是71 $\\pm$ 2.5 (km/s)/Mpc，我的测量值是74 $\\pm$ 5 (km/s)/Mpc。这两个值是一致的吗？这就是一个可以准确回答的问题了。\n",
    "\n",
    "> In visualization of data and results, showing these errors effectively can make a plot convey much more complete information.\n",
    "\n",
    "在数据和结果的可视化中，有效地展示这些误差能使你的图表涵盖和提供更加完整的信息。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Errorbars\n",
    "\n",
    "## 基础误差条\n",
    "\n",
    "> A basic errorbar can be created with a single Matplotlib function call:\n",
    "\n",
    "调用一个Matplotlib函数就能创建一个基础的误差条："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('seaborn-whitegrid')\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWwAAAD1CAYAAAB0gc+GAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAVjElEQVR4nO3dfYxjV3nH8d8GNt060NnwslBCtoQWPZ0qpUtXpGzbNEOm4jUIVGBQyktQdtUihYoqRVUFRVHhDySi8hKo1KKwzQJpylCh0DZRE7HVFFCGLrW0QSrWI4GSRmSBDQW8aYzJBk//8DjxzNoe+/rce8+59/v5a8Ye3/ucudePj59z7rm7NjY2BACI33llBwAAmA4JGwASQcIGgESQsAEgESRsAEgECRsAEvHkvDbcbDaZLwgAGRw8eHDXqMdzS9ibO830ularpcXFxcDRxI021wNtrod52txsNsc+R0kEABJBwgaARJCwASARJGwASAQJGwASQcIGgESQsAEgESRsAEgECbtgS0tLWlpaKjsMAAkiYQNAIkjYAJCITGuJmFlD0i2SniVpj6QPuPu/BowLALBN1h72ayT9l7tfIWlF0ofDhQQAGCVTD9vdPzf068WSvhMmHADAOHMtr2pm90h6rqSrRj3farUybbfb7WZ+bew6nY6kc/83VW7zOLS5HmhzOHMlbHf/bTM7IOmzZvYb7r7lpgVZ14Ot8vq5jUZD0rn/myq3eRzaXA+0eTbB18M2s4NmdrEkuftJ9RP/MzNFBwCYStZBx9+T9GeSZGbPkvQUST8IFRQA4FxZE/bfStpnZl+RdIek69y9Fy4sAMB2WWeJ/ETSHwaOBQAwAVc6AkAiSNgAkAgSNgAkgoQN4HEs/xs3EjYAJIKEDQCJqGXC5msfgBTVMmEDQIpI2EDi+MZYHyRsAEgECRsAEkHCBoBEkLAL1m639cADD2h9fb3sUAAkhoRdoPX1dX3jG9/Qfffdp+XlZZI2gJmQsAu0tramXq+/bPijjz6qtbW1cgMCkBQSdoGWlpZ03nn9f/n555/PVCwAMyFhF+jQoUN64QtfqEsuuUTHjx/XoUOHyg4JQELmums6ZrewsKCFhQWSNR7/hkVpDNOih50ArmRD2TgH40DCBoBEkLABRI3e/RNI2ACQCBI2ACSChA0AiZhrWp+ZfUjS5Zvb+aC7fyFIVACAc2TuYZvZSyVd6u6HJL1C0keDRQUgCZMGBBksDG+eksiXJb1x8+cfSbrAzJ40f0gAgFEyl0Tc/WeSHtn89YikOzcfe1yr1cq07W63m/m10+h0OpKyx5fHvie1ucx485T3cY7RcJtDHdeQ58e4bc36+PBz8x7nFM//vM7tuS9NN7PXSjos6WXbn1tcXMy0zVarlfm102g0GpKyx5fHvie1ucx485T3cY7RcJtDHdeQ58fZs2fVbrf14x//eMvyCeP2MWnfg+f27NkzV2wpnv/znNvNZnPsc3PNEjGzl0t6r6RXunt7nm0BKBfrtcdvnkHHBUk3SrrK3X8YLqT8cdcX4Fys1x6/eUoib5L0DEmrZjZ47G3u/sDcUeVo0Ivo9XpaXl5mmVNg02C99l6vV7v12lNZOXGeQcdPSvpkwFgKMaoXQcIGnlivvd1u69Zbb+V9EaHaXenIXV9QNSFLfAsLC9q/fz/JOlK1S9jc9QVVwkBhvdQuYUv0IlAdDBTWSy0TNlAVdS/x1e3ydxI2kDBKfPXCTXiBxHFj5/qgh10jdfv6CFQNCRsAEkFJpGCM4gPIih42UJKU1rRJKdYqI2FHZFyNmTdL9aR0wUtKsVYdCTtyvFmqKaULXoqKlUHxnZGwI5fSGxvTS+mCl7Jj5RvmE0jYkSv7zYJ8pHTBS5mx8g1zq0ok7Bi/SoWKKaU3NmaT0po2ZcXKN8ytmNaXgFmvZEtlMXZgJzHfVKGM91kletgA4jOoPZ88eTLzNviGuRUJG0Bm4wYEh2vP11577Vy155RKR3kjYQPIZNKA4HDt+ezZs5TnAiFhTynGgU2gTJMGBIdnN+3evZv3TiAkbACZTJpyOlx7Pnr0KOWMQJglAiCTne6yPpjddODAgZIirB4S9pyYQoc64+YJxSJhA3hcXTse7XZb7XZb6+vrUX/4zFXDNrNLzezbZvbOUAEBQJFSuvw9cw/bzC6Q9HFJx8OFU4y69iIAnGvUbJdYe9nz9LB/KulVkk4FigXYgqmUKEJKC6xl7mG7+2OSHjOzsX/TarUybbvb7c702k6nM9f+Bq655hpJ0rFjx6bex6yPj9PtdoNtK9R28rbTcY4t3hCG2xyqfUX8n7KcU4Pnpn0/Z9nH6dOndebMGd12222ZZ6Ps3btXZqYzZ87oxhtv1N69e+eKV5o9h00r10HHxcXFTK9rtVozvbbRaMy1v2m2M+65WR8fp9VqBdtWqO3kbafjHFu8IQy3OVT7Tpw4MXdcO8lyTg2e27Nnz1RtnHUf6+vrcnf1ej0dPnx4rrVG9u3bp3379unqq6+e+jWT2j5rDhvWbDbHPseFMwCSVMTSq7GV5UjYAJKUUu05lMwJ28wOmtmapLdLepeZrZnZ00IFhvC41RKqpI5Lr84z6NiUtBQuFORpMNe01+tpeXm5Nic4qq1uV1pSEqkJbrUEpI+EHZE8SxZZ632xDboAdVbphJ1Ssjl58mSul8fWsd5XNSmdz1kwxrKzSifslJw4cWLmksWsb2ButYRYpbSeR5lYrS8Sl112WbR3h0Y+GEd4QkrreZSpEgk7xqURZ43pwIEDYxeD541dLzGusZ53LIMxFjoskyVVEhlVAojxq1TWmEKVLKgFIjUpjrGU8T5LKmGPEuN0tTJjivEDDJjGuA7L2tpaFO/rYWW9z5JP2DFenlpmTDF+gFVJ1WdqYDplvc+ST9gxfpUqM6YYP8CAqinrfVaJQccYL08tK6ad7mQNYH5lvc8qkbCLEONMlHFi/ABD/QzKBFW6AcWwMt5nJOwpsHBS2mKcJlcVsf5Pq3rMk69hF4GBPAAxIGFPYdIAA3Oegdkw0yY7EvYUxs36YM4zYkdyrBYS9pRGTeqnVAKgSCTsOTDnGami550mEvaQWevRMV60UyWMD6AoMV7+Pkp0CXtpaUnXXHNN4fste8EmbMX4AHCu6BJ2WahHx4XjgRjE9i2PhL2JenRcOB7Iwyy1+xi/5ZGwN1GPjgvHA9PIs/Yc47c8Lk0fwhocceF4oEwx3gUnc8I2s49IeomkDUnvcvevB4sKSExV166os6wr8i0tLanT6ejEiRPBY8pUEjGzKyS9wN0PSToi6RNBo0I0Yht0AYoU2yywrDXsZUm3S5K7f1PShWb2C8GiCoRks9Ws9b6Qgy5cqDE/zmdkLYk8W1Jz6Pfvbz52ZviPsqyD2+l01Ov1Rr620+mM3O6ox0+ePKl7771XGxsbuvLKK3X06FEdOHBgx32Pi3uWfe+0rVG63e7Mrzl9+rTOnDmj2267bUvbZt3OOKurq1sGXVZXV7V3795M2xoVU7fbnRhjqHaE2s6kbU3ax+C6gmPHju3Y5nHbynI+Z403tO1tLiKmUPvImhPG5bB5ZU3Yu0b8vrH9jxYXF2fecKPRUKfTGfnaRqMxcrujHr/99tu1sdEP6ezZs7r//vt19dVX77jvcXHPsu+dtjVKq9Wa6TXr6+tyd/V6PR0+fHjLTIpZ9z3OysqKbrrppscHXVZWVjJvc1RMrVZr4vZCtSPUdiZta9pzZ6c2j9tWlvM5a7yhbW9zETGF2kfWnDAuh02j2WyOfS5rSeRB9XvUA8+R9L2M28pFivN4ZylZFDHlaNLUOkocxUrxfEZ4WRP23ZLeIElm9iJJp9z94WBRjTFLDa/q83iLegMXMehC8t9q1Hle9fMZ08lUEnH3e8ysaWb3SOpJui5sWOfKcpuuKs/j5Wa71TTpPK/y+SwxJXIamedhu/tfhAxkJ6NKAFU9cadV9TdwHXGeY5JkrnScdNVRjJ/MMcaE+bXbbbXbba2vr+eSSGO8ug7xSCZhUwKYHh8W+chSlpsV5zkmSSZhS5QAUK6iyhWc52koo2PEan3AlJhah7KRsFF5WS7pHjXVkKl16ajqZfwkbEiq7lzo0IvQx7YYUIryTqYx3nggFBL2lFK5SSe2inER+iLF1tMsIplW+ZiTsFFpda47x9jTLCKZVvmYk7BRaXWuO8fY0ywimVb5mCc1rS9GMbwJMFldp8lNuggn7wuAxilqnnlVj3l0Pex2u61Tp05F8fUNSNm4nmbZpRIGbrOLKmEPTqQHH3wwmpobkLJRyTHGUgmmE1XC5kQC8lflQbmdxDZrZlZR1bBZ+AbD+MDOR13XKyliLZi8RZWwByfSQw89pM9//vOF/zNJEKiLqg7KTVKFpWujSthS/0TavXt3cv9IAHHL8g0+tk5cVDVsIFWp10broKj52XnOdCNhoxBVTmhlT5PD9PKeUpj3TDcSNnJX9YS20+ymKn9YYau8Z7qRsJG7qk/XnDRNbvuH1cmTJ0uKEkXIe8okCRuZzNJrrPq830m10e0fVidOnCgrTBRgcC5cdNFFudTJo5slElLVenJlGPU/nHU+607zfsta1yKkcdPkts9MuOyyyzLvg/M5DXnOdKOHjZllKXGMG+ypen17e+/7wIEDZYeEhJGwE1bWTRVCljiqXt+WWOwI4WRO2GZ2hZmdNrOrQgaE+IWcz1p2fbuqt0ZDNWWqYZvZL0u6XtJXw4aDVIS6tLmu61pMUsVvGQgj66DjdyX9gaRPBYxlR5zI1VTHdS2ALDIlbHfvSJKZTfy7Vqs187Y7nY56vV6m16as2+2W2uZOpyNp+mMW4u8HbZ51W7OatP1xz4V6fPtzRR/nLPGGtr3NRey7zHbnmcN2TNhmdkTSkW0P3+Dud+302sXFxZkDajQa6nQ6mV6bslarVWqbG42GpOmPWYi/H7R51m0Nas7TfuOatP1xz417fNw86mn3UfRxnrV9edje5iL2XWa7581hzWZz7HM7Jmx3v1nSzZn2DCSqCnPDUT1M64OkcOtdVGHWRdXnhiNdmRK2mb3azNYkvULSB83s7qBRoVAkqK3qMDccaco66HiHpDsCx4KSVOFOHJPMmnC5VV36qvohW+m1RDAdEtRWzA3PV1WTaRFI2KhMgpp19sgkVZkbTnKsFhI2JFUnQQFVxiwRAEgEPWyghiiVpCm6hL22tla7y9IBYBqURAAgESRsAEhEdCURAMhL6rV7etgAkAgSNgAkgpIIEEDqX7URTp4z3ehhA0Ai6GGjEHXugda57QiLHjYAJIKEDQCJoCSCTKryNZ97NyIlJGyUrqzkP7g1Wq/X0/Lyso4fP07SRtQoiaC2uHcjUkPCRnJC3uH9vPP6bwFujYYUkLCRlJB3eB/cGu2SSy6hHIIkkLARVKje7zihyxgLCwvav38/yRpJIGEjmJC933EoY6DOSNgIpohBPMoYqLNM0/rM7MmSPiXp+ZJ2S3q3u381ZGBIz6D32+v1cu39FnGHd2aMIEZZe9hvlfSIu18u6bCkD4cLCWVYW1ubO0mV3fvNu34OlC1rwv6spOs3f35I0tPDhIPUlTWIV0T9HChbppKIu5+VdHbz1z+V9A+j/i7rmrDdbrd2d06vSps7nY6k6Y591jaP2sfq6uqW+vnq6qr27t0bNN4QqnKcZ0Gbw9kxYZvZEUlHtj18g7vfZWbXSfpNSa8Z9drFxcVMQbVarcyvTVVV2txoNCRNd+yztnnUPlZWVnTTTTc9Xj9fWVmZatuzxBtCVY7zLGjzbJrN5tjndkzY7n6zpJu3P25mh9VP1K/b7HEDpRnUz9vttm699VZmj6CSss4Seb6kd0i6wt27YUMCsili9ghQpqyr9R1Rf6DxTjMbPPYyd380SFQAgHNkHXR8j6T3BI4FADABVzoCQCJI2ACQCBI2ACSChA0AiSBhA0AiSNgAkAgSNgAkgoQNAIkgYQNAIkjYAJAIEjYAJCLr4k9AJXDvRqSEHjYAJIKEDQCJIGEDQCKoYSM51J1RVyRsBEUyBfJDSQQAEkHCBoBEkLABIBHUsFEZ1M9RdfSwASARJGwASAQJGwASkamGbWb7JB2TtEfS+ZKud/f/DBkYAGCrrD3st0j6jLu/VNJ7JH0gXEgAgFEy9bDd/cNDv14s6TthwgEAjLNrY2Mj0wvN7NmS/kXSUyVd6e6nhp9vNpsbjUYj07a73a727NmT6bWpos31QJvrYZ42dzodHTx4cNeo53bsYZvZEUlHtj18g7vfJenFZvYqSbdIetn21y4uLs4eraRWq5X5tamizfVAm+thnjY3m82xz+2YsN39Zkk3Dz9mZleY2YXu/iN3v9PMPp0pMgDA1DKVRMzsY5Luc/ePmtmvS/q0u79o+G+azWa2WgsA1Ny4kkjWhP0M9af1PVXSz0l6l7t/ba4IAQATZR50BAAUiysdASAR0a3WZ2YfkfQSSRvql1q+XnJIuTOzD0m6XP3j8UF3/0LJIRXCzH5e0n9Ler+731JyOLkzszdL+nNJj0l6n7vfWXJIuTKzp0j6tKSnqX9F9F9tzi6rHDO7VNIXJX3E3T9hZhdL+oykJ0n6rqS3uvtP591PVD1sM7tC0gvc/ZD6Uwk/UXJIuTOzl0q6dLPNr5D00ZJDKtJfSvrfsoMogpk9XdINkn5X0lWSXlduRIV4uyR39yVJb5D0sVKjyYmZXSDp45KODz38fkl/4+6XS7pf0rUh9hVVwpa0LOl2SXL3b0q60Mx+odyQcvdlSW/c/PlHki4wsyeVGE8hzOxXJf2apDvKjqUgvy/pS+7+sLt/193/qOyACvADSU/f/PnCzd+r6KeSXiVp+OLBJUn/vPnzF9U//nOLLWE/W9JDQ79/f/OxynL3n7n7I5u/HpF0p7v/rMyYCvLXkq4vO4gCPU/SLjP7nJl9xcyWyw4ob+7+j5L2m9m31O+YvLvkkHLh7o+5+0+2PXzBUAnke5J+McS+YkvY2+ce7lK/ll15ZvZaSYclvbPsWPJmZm+TtO7u95UdS4F2SXqupDerXyr4ezMbOde2KszsLZIecPdfkXSl+mWDuhjOW8HyWGwJ+0Ft7VE/R/1Pp0ozs5dLeq+kV7p7u+x4CvBqSa81s6+p/63ifWYW5CtjxL4v6Z7N3ti3JT0s6Zklx5S335F0lyS5+72SLjKz6CY65OSRzUF1SbpI/YHHucWWsO9Wf3BCZvYiSafc/eFyQ8qXmS1IulHSVe7+w7LjKYK7v8ndX+zuL1F/2YMPuPuXyo4rZ3dLutLMztu88Owpqm5Nd+Bbkn5LkszslyT9n7s/Vm5IhfmSpNdv/vx6Sf8WYqNRfdq5+z1m1jSzeyT1JF1XdkwFeJOkZ0haNbPBY29z9wfKCwmhufuDZvZPkv5dUkPSn7h7r+Sw8vZ3ko6a2X+on2veUXI8uTCzg+qPyTxP0lkze4P6pa9bzOyPJf2P+leGz40rHQEgEbGVRAAAY5CwASARJGwASAQJGwASQcIGgESQsAEgESRsAEgECRsAEvH/c/miiL+rFhwAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0, 10, 50)\n",
    "dy = 0.8\n",
    "y = np.sin(x) + dy * np.random.randn(50)\n",
    "\n",
    "plt.errorbar(x, y, yerr=dy, fmt='.k');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Here the ``fmt`` is a format code controlling the appearance of lines and points, and has the same syntax as the shorthand used in ``plt.plot``, outlined in [Simple Line Plots](04.01-Simple-Line-Plots.ipynb) and [Simple Scatter Plots](04.02-Simple-Scatter-Plots.ipynb).\n",
    "\n",
    "这里的`fmt`参数是用来控制线条和点风格的代码，与`plt.plot`有着相同的语法，参见[简单的折线图](04.01-Simple-Line-Plots.ipynb)和[简单的散点图](04.02-Simple-Scatter-Plots.ipynb)。\n",
    "\n",
    "> In addition to these basic options, the ``errorbar`` function has many options to fine-tune the outputs.\n",
    "Using these additional options you can easily customize the aesthetics of your errorbar plot.\n",
    "I often find it helpful, especially in crowded plots, to make the errorbars lighter than the points themselves:\n",
    "\n",
    "除了上面的基本参数，`errorbar`函数还有很多参数可以用来精细调节图表输出。使用这些参数你可以很容易的个性化调整误差条的样式。作者发现通常将误差线条颜色调整为浅色会更加清晰，特别是在数据点比较密集的情况下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWwAAAD1CAYAAAB0gc+GAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAZDElEQVR4nO3df2wkZ3kH8O+eSbu98EO55PCdIVfUFj1175o0tWhDSxogyHDBCAS0kboEIXK6IoUqurRXVbi5XA+5SETlQOQkekpLCFgqFCHSOkdjkSolVZqWjtqefKyeCkQTkdjWXR3RNMuSxN7+sfayHu/s7rz7zsz7vvP9SJbWu96ZZzyzz77zvO+8U2m1WiAiIvftKjoAIiIaDhM2EZEnmLCJiDzBhE1E5AkmbCIiTzBhExF54mVZLTiKIo4XJCIyMDU1Ven1fGYJe3OlRu+r1+uYnJy0HI3buM3lwG0uh1G2OYqixNdYEiEi8gQTNhGRJ5iwiYg8wYRNROQJJmwiIk8wYRMReYIJm4jIE0zYRESeyPTCGdppdXW183h8fLzASIjIN0zYObt48WLnMRM2EaXBkggRkSeMWtgishvA/QDGAVQBfFxVFyzGRUREMaYt7HcB+DdVvRHA7wD4lL2QiIioF6MWtqp+uevXqwH8wE44RESUpNJqmU9bLSKPA3gtgBlVPd/9WhRFrd27dxstt9lsolqtGsflsvX19c7jsbGxzuOQtzkJt7kcuM3pNBqNbObDVtXfEJFfAfAlEblWVbdlf9P5YEOeP3dpaanzuHsbQ97mJNzmcuA2p2N9PmwRmRKRqwFAVf8D7cS/1yg6IiIaimmn428B+AMAEJFxAC8HcMlWUEREtJNpwv4cgFeLyGMAHgJwu6pu2AuLiIjiTEeJ/AjA71qOhYiI+uCVjkREnmDCJiLyBBM2EZEnOFsfEXVw+l+3MWETUQen/3UbSyJERJ4oZQubp31E5KNSJmye9hGRj0qZsIlCwjPG8mDCJvIczxjLg52ORESeYMLO0fz8PKanp3HNNddgenoa8/PzRYdERB5hSSQn8/PzOHr0KBqNBgBgeXkZR48eBQDUarUiQyMiT7CFnZPZ2dlOst7SaDQwOztbUERE5Bsm7Jw89dRTqZ4nIopjws7JgQMHUj1PRBTHhJ2Tubk5xO8iv3v3bszNzRUUERH5hgk7J7VaDWfPnsX+/ftRqVSwf/9+nD17lh2OJba6utr5IRoGR4nkqFar4dprr+38fujQoaHexyvZwuTTBS88Bt3AhO0Bnz7YFCYeg25gwiYip7F1/xNM2ETkNLbuf4KdjkREnmDCJiLyxEglERH5JIAbNpfzCVX9mpWoiIhoB+OELSJvAXBIVd8oIlcC+HcATNhEJdKvQ3DrtY2NjVxjCtkoLexvAfjXzcfPArhcRMZUdX30sIjIB/06BLtfIzsqrVZr5IWIyFEAN6jqrVvPRVHUil+KPaxms4lqtTpyXEnW13/ynTI2NpbZetKsu982FxlvlrLezy7q3mZb+9XWchYWFnD69GmsrKxg3759OHbsGGZmZvquo9+6Xdu+PI1ybDcaDUxNTVV6vTbysD4ReTeA2wBMx1+bnJw0Wma9Xjd+7zCWlpY6j7NcT5p199vmIuPNUtb72UXd22xrv9pYzvz8PE6ePLltvvaTJ09iYmICtVotcR391u3S9uVtlGM7iqLE10YaJSIibwcwC+Cwqv5wlGXlhXd9IdqJ87X7YZROx1cBuAfA21R1zV5I2eFdX4h643ztfhilhX0LgKsAfEVEHt38cXpyZ7YiiHor+3ztvsycaNzCVtWzAM5ajCVzbEVQaObn53H8+PFOR+E999xjdLY4Nze37ewTKNd87b5c/l6qKx3L3oqgsGyV+JaXl9FqtTolPpN+Gc7X7odSJWze9YVCYrvEV6vVsLi4iPPnz2NxcZHJ2kGlSthsRVBIWOIrn9JNr2p61xci1xw4cABPPvlkz+fLomxzZZeqhU0UEpb42p2FWz9lwIRN5CmW+MqndCWRMivb6WMZsMRXLkzYJeLLWFMi6o0lkZzt3bu380Pl5dOcNj7FGjom7JyNj493fobBD0t4bF7wkjWfYi0DJmyHxOcz4IclTD7NaeNTrGXAhO2Q+BAlfljC5NMFL3nG2msCJp5hbseE7TCfPtg0PJ/mtMkz1niDhWeYOzFhO8ynDzYNz6cLXoqMlWeYOwWRsF2cy9ZGTD59sGl4Pl3wUmSsPMPcKYhx2C6OL7YR09aHIu18x7xAxn0+XfBiEquNebpdnyuliM9ZEAk7ZCYfFhe/wCg8SUnZ1q34XL+pQhGfsyBKIkSUr34dgrZqzz6VjvLCFjYRpdYvKdusPftUOsoDW9hDcrFjk6go/ZIyRzdlhwl7SGWbd5eon35JmaObssOETUSp9UvKrD1nhzXsEXEIHZXRoCGnPtWebQxBzAsT9og4hI5CkmbaX5+SchJbQxDzMlJJREQOicj3ROSjtgIiouKknf7Xd75d/m7cwhaRywF8FsAj9sLJB28eQESAf5e/j9LC/jGAmwE8YymW3JStFeErDqWkfmxMverbEMRKq9UaaQEichLAJVW9t/v5KIpa8V7kYTWbTVSr1aH/fn19vfN4bGzMaJ0AsLGx0Xm8a9f277KkdaR9Pkmz2cRll11mZVm2YsraoP3sWrw2dG+zre3L4/9kckxledwuLCzgxIkTaDabndeq1SpOnTqFmZmZgevaMspy+m1f2hzWrdFoYGpqqtLrtUw7HScnJ43eV6/XU713aWlp5HUOWk7Sa2mfT1Kv17cdAKMsy1ZMWRu0n12L14bubba1fXmMVDI5prI8bg8fPrwtyQLtJHnmzBkcP3584Lq6lzcxMWE0SqTf9qXNYd2iKEp8jaNEiDxXxtJeXpe/uzZslxfOlARvtUQhyav27NoVzsYJW0SmRORRAB8CcIeIPCoie2wFRvbwVksUmrJe/m5cElHVCMCb7YVCWek31tTFiwOIBjG9uYfvWMN2xMLCAk6fPp3JwefbWFOiYYRwpWVarGE7YH5+HidOnMisZDFKvY9joSkP7GMZTtAJ25dkMzs7u2OIks3LY0ep97nW6VJmvhzPabGPZXhBJ2xfko1pyWLYDzCnuwyDL8dzWr7N51Ek72vYLk6NmDYm07tDp5kpsIz1PtdxTps29rEMz+sWtounUiYxzc3N7biMtbtksXfv3s7PMOtnLdAPSXPauFj6SHMMpuXbfB5AcZ8zrxJ2/EB28VTKJKZarYZTp04lliyGnazKxS8wSs/F0keWE6b5Nqa6yM+ZVyWReAnAxVMp05hmZmZw+PDhzu8mJQuOtyYfDRpT7VrpqMjPmVcJO8609pulImNy8QssNK7NLRGKfn0srv2fi/yceVUSiXPxVKrImHysBfrGxXIF5avIz5nXCTuv4WppOhiKHELn4hcYUWiK/Jx5XRIBsh+uZnKTzqKG0JV1fgVy01bt+dKlSwVHYleRnzPvE3bWfOvI43jrnVh3zk6/DsGt//Xa2lpe4XRkvc+L+px5XRLJQ78OBo559gPrztlx9f6ooe5ztrAHSBr1sWfPntSlEiLiGc8o2MIeIKmDAYBzF+0Qxbl41WSord88MGEPkDTqI6kuxzHP5BImx7AwYW/qV4+u1WpYXFzE+fPnsbi4iFqtxjHPGWP/QLZcbHnTYEzYMJ+wiWOes8E5UbLHlvd2WU5uZZNzCXt1dRUbGxu5fvObTtjEOaaz4eKkXhS2XqNdXDzLc26UyNY3/sWLF3PrQTadG4BjnrPBOVGoaCYXzOXBuRZ2EViPdgv3B2Vl2Nq9q2d5TNhgPdo13B80rLS152Fr966e5TFhg/Vo13B/0LCyutLS1bM84xq2iJwGcD2AFoA7VPXb1qIqAOvROxV5v0zf9gev3gvL3Nzctho2MPxZXvfACdvHglELW0RuBPB6VX0jgCMA7rUalQUu9vD6hEPr0sl6mByP53yNcpZ38eJFtFqtTI4F0xb2TQC+DgCq+h0RuUJEXqmq/2svNHOu9vDaZNL6TTPG1PYshWyBmivD8ewiF8/yKq1WK/WbROQsgIdU9cHN3x8DcJuq/tfW30RR1Ip3HA1jfX2983hsbGyo1+LP33TTTVheXt6x7P379+ORRx7JdN3DLKuXZrOJyy67bKj3LCws4MSJE2g2m53nqtUqTp06hZmZmdTr7uXgwYPodWxUKhVcuHAh9fJ6xdRsNnfcLX7Qe0zYWk6/ZfVbx8bGRufxCy+80Hebey3L9Hg2jde2+H7OIyZb67CZE4bVaDQwNTVV6fWaaQs7vrAK2rXsbSYnJ1MveGlpKfH9Sa/Fn19ZWem57JWVlb4x2Vj3MMvqpV6vb9vR/d5z+PDhbckaaH8ozpw5g+PHj6dedy/97k1pa7/W63Xj/THqum0va9hjp1qtDozB1vFsGq9t8f2cR0y21mEzJwwriqLE10xHiTwNYF/X7xMAeh9VlqSp4bnawzvIsEOU8hhyNGhoHeeiyEav49zX45nsM03YiwDeDwAich2AZ1T1OWtRxaTtAPN1HO+wQ5Ty+AAP6nSx2cnG5N+WdJzffPPNXh7PZJ9RwlbVxwFEIvI4gM8CuN1qVDFprzoKfRxvXl9IvWYpzAInImpLOs7PnTsX9PG8xZcJmIpkPA5bVf/YZiD9mJQAXOzhtYU32y1G1uPS+x3nIR/PWzh6aDDnJn/qpV8HGJBuuFpeso6pDB9gl+QxtG7QcU7kxaXpg0oALt4ItMiYeGppXx6TAfna90L58aKFzRJAOi59cYUij5E5PM79UkSDyIuEDbAEQGZs1Z3zKlfwOB9dXnPgFNEw8qIkQmRilPlQ4kMNWa6wI+s5UUKfA4cJmwCEORZ6lLpzfKihj0NFXZswKo9k6uqNB2zxpiRStNA78LrHQIdSA7ddd/apXOHihFG2JxTrxdUbD9jCFvaQXByJQv2V+ZJuF1uaeSTT0Pc5EzYFq8x1537JsahSSR7JNPR97lTCdq3mNgyOeXaXj3VnW5KS4J49ewrrlMsjmYa+z52pYbtYcxsGSyRu86nubFPSLa4AZF5HTpLXOPOQ97kzLWwXa25Evkpqaa6trfX8+7w65fKaUKwXH8/g45xpYYfeu0uUt14tzdnZ2VLOV+LrGXycMy3s0Ht3KT32D9gXeqdcklDO4J1J2C4cSEwQbuFQSvtC75RLEsoZvDMlERcmvmFiIBN5zV1hS8idcklM54JJ23jL+lhwJmED5TyQysC3hJZGKLXR0CWNmhl0Bp+mEZfHseBMSYTCFPpkPINqo/GRCQsLC0WEWXp5lILyqJM71cKm8PQ7iL/xjW8UFJU9g64ojLe4Tpw4gYmJCba+C5D1GXwedXK2sCm1NONZQ+nsSdJvdFOvL6tms+ndyAQaTh4j3ZiwKZW0JY5BB7HvFzP0G90U+pcVbZfHSLegEzaH6Y0u/j9MW6frdxAvLCx4X9/uVxu13eLi8ey2POrkQdewOUxvdPH/YdpWY7/hmhMTE4XNa2FTUm2018iEarVq3OLi8ey+rOvkQSfs0BXR0jIZz5p0EK+srPT8+1BKBr2+rI4dO+bVlxG5xThhi8iNAP4GwIdVlWOVClBEi8t0PGsv+/btw/Ly8o7n85yOoPuWaFn8P+NfVmNjY9bXQeVhVMMWkZ8HcCeAf7IbDrnOZp3u2LFjhU9HEL93owtYq6Ykpi3sZQDvBfCXFmMZiAewG2zV6WZmZjAxMRHsVZCmWKumJJVWq2X8ZhG5H8BXe5VEoihqxVtPw1hfX+88LtPpY7PZRLVaLWz9af/vNv5+a5uz3uf9lp/0mq3n46+9+OKLue5nk3htix/beay7yO0edR2NRgNTU1OVXq8NbGGLyBEAR2JP362qDw967+Tk5HARdllaWhrp/b6q1+uFbm/a/7uNv9/a5rTLSlt37rf8Xq/1m/skad3DrqNarea6n5PiyvNzFj+281h3kds96jqiKEp8bWDCVtX7ANyXeq3kDd8mZ+quN9suHwyawIflCipS0BfO0GC2J2daXV3t/PgolInuKUymo0TeKSKPAngHgE+IyKLVqCg3thOUi6Mu0uDl5OQyo1EiqvoQgIcsx0IFKEOCSjO6yHSie3JLqCPKeKVjyZUhQaWpO9u8MIh6yyOZhtrXwBp2yblwL01bbNTPQ7vnoYsX4fBenebYwi45F+6laYut0SMh3aqOSTEsTNgUVIIiChkTNlEJuVQioeE5l7D37t2LS5cu4aqrrio6FKJgsVTiJ+c6HcfHx7Fr1y4eUEREMc4lbCIi6s25kggRUVZ8r90zYRNRafheamVJhIjIE2xhE1ng+6k22ZPlSDcmbCILfD/VJnvGx8extraWyTHBhE25KHMLtHvb19bWCoyEfMeETbkocwu0e9uZsGkU7HSk0pqfn8f09DSuueYaTE9PG99lhygvbGGTEd9LHIPu3UjkIrawyYjNOY2LmLOZ924kHzFhU+HSJH9bZYwy3BqNwsOETd6weYf3pFughXRrNAoPEzZZk3Unns0yRki3RqPyYMImK2y2fpPYLGOEdu9GKgeOEiEr+rV+bSVB23d4563RyDdsYZMVeXTisYxBZWeUsEXkZSLyBRF5TESeEJE32Q6M/JJHJ16/Mobt+nkRQw2JBjEtidwK4HlVvUFEDgL4PIBfsxcW5W3UxDQ3N7ftQhQgm9ZvrzJGFhfBlPlSenKXaUnkSwDu3Hx8EcCVdsKhoox6IUyRnXi8CIbKotJqtUZagIj8GYB1Vb2r+/koilrxeuOwms0mqtXqSHH5JpRtXl9f7zweGxvr+7em2xxfx8GDB9HrOK5UKrhw4UKqZWUtlP2cBrc5nUajgampqUqv1waWRETkCIAjsafvVtWHReR2AL8K4F293js5OZk2VgBAvV43fq+vQtnmpaWlzuNB22O6zfF19Bs9Mmj5aeK1IZT9nAa3OZ0oihJfG5iwVfU+APfFnxeR29BO1O9R1ReNIiOyIK/6OVHRTEeJ/ByAjwB4r6o27YZElA4vgqGyMB0lcgTtjsZzIrL13LSqvmAlKqKUeBEMlYFRwlbVjwH4mOVYiIioD17pSETkCSZsIiJPMGETEXmCCZuIyBNM2EREnmDCJiLyBBM2EZEnmLCJiDzBhE1E5AkmbCIiTzBhExF5gndNp1LjPRvJJ0zYVGq8dyP5hCURIiJPMGETEXmCJRHyDuvOVFZM2GRVHsmUdWcqKyZssorJlCg7rGETEXmCCZuIyBMsiVAw2BlJoWPCpmCwfk6hY0mEiMgTTNhERJ4wKomIyKsBfAFAFcBPAbhTVf/FZmBERLSdaQv7AwC+qKpvAfAxAB+3FxIREfVi1MJW1U91/Xo1gB/YCYeIiJJUWq2W0RtFZB+AvwPwCgBvVdVnul+Poqi1e/duo2U3m01Uq1Wj9/qK21wO3OZyGGWbG40GpqamKr1eG9jCFpEjAI7Enr5bVR8G8AYRuRnA/QCm4++dnJxMHy2Aer1u/F5fcZvLgdtcDqNscxRFia8NTNiqeh+A+7qfE5EbReQKVX1WVc+JyANGkRER0dCMSiIi8hkA31fVT4vILwN4QFWv6/6bKIrMai1ERCWXVBIxTdhXoT2s7xUAfhrAHar6xEgREhFRX8adjkRElC9e6UhE5AnnJn8SkdMArgfQQrvU8u2CQ8qciHwSwA1o749PqOrXCg4pFyLyMwAuADilqvcXHE7mRKQG4I8AvATgLlU9V3BImRKRlwN4AMAetK+I/tPN0WXBEZFDAB4EcFpV7xWRqwF8EcAYgGUAt6rqj0ddj1MtbBG5EcDrVfWNaA8lvLfgkDInIm8BcGhzm98B4NMFh5SnPwHwP0UHkQcRuRLA3QDeBGAGwHuKjSgXHwKgqvpmAO8H8JlCo8mIiFwO4LMAHul6+hSAM6p6A4D/BvBhG+tyKmEDuAnA1wFAVb8D4AoReWWxIWXuWwB+e/PxswAuF5GxAuPJhYj8IoBfAvBQ0bHk5G0Avqmqz6nqsqoeLTqgHFwCcOXm4ys2fw/RjwHcDKD74sE3A/jbzccPor3/R+Zawt4H4GLX76ubzwVLVddV9fnNX48AOKeq60XGlJM/B3Bn0UHk6HUAKiLyZRF5TERuKjqgrKnqXwM4ICLfRbth8ocFh5QJVX1JVX8Ue/ryrhLICoD9NtblWsKOjz2soF3LDp6IvBvAbQA+WnQsWRORDwL4Z1X9ftGx5KgC4LUAamiXCj4vIj3H2oZCRD4A4ClV/QUAb0W7bFAW3XnLWh5zLWE/je0t6gm0v52CJiJvBzAL4LCq/rDoeHLwTgDvFpEn0D6ruEtErJwyOmwVwOObrbHvAXgOQOj3NPtNAA8DgKr+J4DXiIhzAx0y8vxmpzoAvAbtjseRuZawF9HunICIXAfgGVV9rtiQsiUirwJwD4AZVV0rOp48qOotqvoGVb0e7WkPPq6q3yw6rowtAniriOzavPDs5Qi3prvluwB+HQBE5GcB/J+qvlRsSLn5JoD3bT5+H4C/t7FQp77tVPVxEYlE5HEAGwBuLzqmHNwC4CoAXxGRrec+qKpPFRcS2aaqT4vIVwH8A4DdAH5fVTcKDitrfwHgr0TkH9HONR8pOJ5MiMgU2n0yrwPwooi8H+3S1/0i8nsAnkT7yvCR8UpHIiJPuFYSISKiBEzYRESeYMImIvIEEzYRkSeYsImIPMGETUTkCSZsIiJPMGETEXni/wHjAwsJ3YtXJAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.errorbar(x, y, yerr=dy, fmt='o', color='black',\n",
    "             ecolor='lightgray', elinewidth=3, capsize=0);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> In addition to these options, you can also specify horizontal errorbars (``xerr``), one-sided errorbars, and many other variants.\n",
    "For more information on the options available, refer to the docstring of ``plt.errorbar``.\n",
    "\n",
    "除了上面介绍的参数，你还可以指定水平方向的误差条（`xerr`），单边误差条和其他很多的参数。参阅`plt.errorbar`的帮助文档获得更多信息。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Continuous Errors\n",
    "\n",
    "## 连续误差\n",
    "\n",
    "> In some situations it is desirable to show errorbars on continuous quantities.\n",
    "Though Matplotlib does not have a built-in convenience routine for this type of application, it's relatively easy to combine primitives like ``plt.plot`` and ``plt.fill_between`` for a useful result.\n",
    "\n",
    "在某些情况下可能需要对连续值展示误差条。虽然Matplotlib没有內建的函数能直接完成这个任务，但是你可以通过简单将`plt.plot`和`plt.fill_between`函数结合起来达到目标。\n",
    "\n",
    "> Here we'll perform a simple *Gaussian process regression*, using the Scikit-Learn API (see [Introducing Scikit-Learn](05.02-Introducing-Scikit-Learn.ipynb) for details).\n",
    "This is a method of fitting a very flexible non-parametric function to data with a continuous measure of the uncertainty.\n",
    "We won't delve into the details of Gaussian process regression at this point, but will focus instead on how you might visualize such a continuous error measurement:\n",
    "\n",
    "这里我们会采用简单的*高斯过程回归*方法，Scikit-Learn提供了API（参见[Scikit-Learn介绍](05.02-Introducing-Scikit-Learn.ipynb)）。这个方法非常适合在非参数化的函数中获得连续误差。我们在这里不会详细介绍高斯过程回归，仅仅聚焦在如何绘制连续误差本身：\n",
    "\n",
    "译者注：新版的sklearn修改了高斯过程回归实现方法，下面代码做了相应修改。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.gaussian_process import GaussianProcessRegressor\n",
    "\n",
    "# 定义模型和一些符合模型的点\n",
    "model = lambda x: x * np.sin(x)\n",
    "xdata = np.array([1, 3, 5, 6, 8])\n",
    "ydata = model(xdata)\n",
    "\n",
    "# 计算高斯过程回归，使其符合 fit 数据点\n",
    "gp = GaussianProcessRegressor()\n",
    "gp.fit(xdata[:, np.newaxis], ydata)\n",
    "\n",
    "xfit = np.linspace(0, 10, 1000)\n",
    "yfit, std = gp.predict(xfit[:, np.newaxis], return_std=True)\n",
    "dyfit = 2 * std  # 两倍sigma ~ 95% 确定区域"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> We now have ``xfit``, ``yfit``, and ``dyfit``, which sample the continuous fit to our data.\n",
    "We could pass these to the ``plt.errorbar`` function as above, but we don't really want to plot 1,000 points with 1,000 errorbars.\n",
    "Instead, we can use the ``plt.fill_between`` function with a light color to visualize this continuous error:\n",
    "\n",
    "我们现在有了`xfit`、`yfit`和`dyfit`，作为对我们数据的连续拟合值以及误差限。当然我们也可以像上面一样使用`plt.errorbar`绘制误差条，但是事实上我们不希望在图标上绘制1000个点的误差条。于是我们可以使用`plt.fill_between`函数在误差限区域内填充一道浅色的误差带来展示连续误差："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 可视化结果\n",
    "plt.plot(xdata, ydata, 'or')\n",
    "plt.plot(xfit, yfit, '-', color='gray')\n",
    "\n",
    "plt.fill_between(xfit, yfit - dyfit, yfit + dyfit,\n",
    "                 color='gray', alpha=0.2)\n",
    "plt.xlim(0, 10);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Note what we've done here with the ``fill_between`` function: we pass an x value, then the lower y-bound, then the upper y-bound, and the result is that the area between these regions is filled.\n",
    "\n",
    "注意上面我们调用`fill_between`函数：我们传递了的参数包括x值，y值的低限，然后是y值的高限，结果是图表中介于低限和高限之间的区域会被填充。\n",
    "\n",
    "> The resulting figure gives a very intuitive view into what the Gaussian process regression algorithm is doing: in regions near a measured data point, the model is strongly constrained and this is reflected in the small model errors.\n",
    "In regions far from a measured data point, the model is not strongly constrained, and the model errors increase.\n",
    "\n",
    "上图为我们提供了一个非常直观的高斯过程回归展示：在观测点的附近，模型会被限制在一个很小的区域内，反映了这些数据的误差比较小。在远离观测点的区域，模型开始发散，反映了这时的数据误差比较大。\n",
    "\n",
    "> For more information on the options available in ``plt.fill_between()`` (and the closely related ``plt.fill()`` function), see the function docstring or the Matplotlib documentation.\n",
    "\n",
    "如果需要获得`plt.fill_between`（以及类似的`plt.fill`函数）更多参数的信息，请查阅函数的帮助文档或Matplotlib在线文档。\n",
    "\n",
    "> Finally, if this seems a bit too low level for your taste, refer to [Visualization With Seaborn](04.14-Visualization-With-Seaborn.ipynb), where we discuss the Seaborn package, which has a more streamlined API for visualizing this type of continuous errorbar.\n",
    "\n",
    "最后，如果你觉得本节的内容过于浅显，请参考[使用Seaborn进行可视化](04.14-Visualization-With-Seaborn.ipynb)，该小节会讨论Seaborn包，提供了将这种类型连续错误条进行可视化的流式API。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--NAVIGATION-->\n",
    "< [简单的散点图](04.02-Simple-Scatter-Plots.ipynb) | [目录](Index.ipynb) | [密度和轮廓图](04.04-Density-and-Contour-Plots.ipynb) >\n",
    "\n",
    "<a href=\"https://colab.research.google.com/github/wangyingsm/Python-Data-Science-Handbook/blob/master/notebooks/04.03-Errorbars.ipynb\"><img align=\"left\" src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open in Colab\" title=\"Open and Execute in Google Colaboratory\"></a>\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
